package nan.classes_and_objects;

/*
编写一个类Calculator,有两个属性num1,num2,这两个数据的值，不能在定义的同时
初始化，最后实现加减乘除四种运算.
 */
    class Calculator{
            private int num1;
            private int num2;
            public Calculator(){//构造方法传参

            }
    public Calculator(int num1, int num2) {//带有两个参数的构造函数
        this.num1 = num1;
        this.num2 = num2;
    }

    public int getNum1() {//getter / setter 方法
        return num1;
    }

    public void setNum1(int num1) {
        this.num1= num1;//this.num1访问的是10，代表当前对象的引用
    }

    public int getNum2() {
        return num2;
    }

    public void setNum2(int num2) {
        this.num2 = num2;
    }
    public int add(){
                return this.num1+this.num2;//this代表当前对象的引用
    }
    public int sub(){
                return this.num1-this.num2;
    }
    public int mul(){
        return this.num1*this.num2;
    }
    public double dev(){
        return this.num1*1.0/this.num2;//两个数字可能都是整型，
        // 所以先给num1*1.0再进行除法
    }
}
/*
交换两个数字
 */
    class Myvalue{
        public int val;//成员属性
    }

/*
person
 */
    class Person{
        public int age;//成员属性
        public String name;//成员属性
        public static int count=0;//静态成员变量,不属于对象
        public void eat(){//成员方法
            System.out.println("吃饭");
        }
        public void sleep(){//成员方法
            System.out.println("睡觉");
        }
        public void show(){
            System.out.println("我叫"+name);
            func();
        }
        public static void func(){//静态成员方法
            /*在静态方法内是不能去调用非静态方法的
            1.show方法要通过对象的引用来进行访问，Person person=new Person();
            2.func()是不依赖对象的,Person.func();
             */
            //show();
            System.out.println("func!!!");
        }
    }

/*
Student
*/
 class Student{
    private String name;//普通成员属性
    public int age;//普通成员属性
    public void show(){//普通成员方法
        System.out.println("我叫"+this.name+"年龄"+this.age);
    }
    public String getName(){//得到名字
        return name;//返回name
    }
    /*public void setName(String MyName){
            name=MyName;//传过来的nan赋值给name
    }
     */
    public void setName(String name){
        this.name=name;//this指当前对象的引用
    }
    public Student(){//构造方法1
        //System.out.println("Student()!!!");
        this("nan");//调用带有一个参数的构造方法，且这个参数是String
    }
    public Student(String name){//构造方法2
        this.name=name;
        System.out.println("Student(String)!!!");
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}
class PrivateTest {//匿名对象
    public String name;
    public int age;

    public PrivateTest(String name) {//构造方法2
        this.name=name;
    }
    public PrivateTest() {//构造方法1
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show() {

    }
}

public class Main {
    public static void main6(String[] args) {
        Calculator calculator=new Calculator();
        calculator.setNum1(10);//借助setNum1赋值
        calculator.setNum2(20);
        System.out.println(calculator.add());

    }
    public static void main5(String[] args) {
        new PrivateTest();//匿名对象
    }
    public static void main(String[] args) {
        PrivateTest student1=new PrivateTest();//实例化对象，调用构造方法1
        PrivateTest student2=new PrivateTest("nan");//实例化student2并且
        //给了一个参数“nan”，调用构造方法2
        System.out.println(student2.getName());//通过调用getName得到名字
        student1.setName("nan");//将nan传给myName
        System.out.println(student1.getName());//调用getName
        student1.age=21;
        student1.show();
        System.out.println(student1);

    }
        public  static void swap( Myvalue a, Myvalue b){//交换a，b的值
            int tmp=a.val;
            a.val=b.val;
            b.val=tmp;
        }
    public static void main3(String[] args) {
        Myvalue myValue1=new Myvalue();//实例化一个对象；
        myValue1.val=10;//访问成员变量val，将myValue1初始化为10
        Myvalue myValue2=new Myvalue();
        myValue2.val=20;
        swap(myValue1,myValue2);//调用swap方法
        System.out.println(myValue1.val);
        System.out.println(myValue2.val);
    }
    public static void main2(String[] args) {
        Person.func();//类名.静态成员变量，来访问静态方法
        Person person=new Person();//1.实例化一个对象，person：对象的引用
        person.show();//2.访问成员方法，通过对象的引用
        System.out.println(Person.count);//访问静态成员变量
        person.name="zhu";//访问普通成员变量（对象引用.成员变量名），初始化name
        System.out.println(person.name);
        person.sleep();
    }
    public static void main1(String[] args) {
        Person person=new Person();//new实例化一个对象，创建一个对象
    }
}

